package com.example.lin.common;

import jakarta.annotation.Resource;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.time.Duration;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * @author Administrator
 */
@Service
public class RedisService {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 构造方法
     * @param redisTemplate redisTemplate
     */
    public RedisService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 设置缓存
     * @param key 键
     * @param value 值
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 设置缓存
     * @param key 键
     * @param value 值
     * @param time 超时时间，单位：秒
     */
    public void set(String key, Object value, long time) {
        redisTemplate.opsForValue().set(key, value, Duration.ofSeconds(time));
    }

    /**
     * 添加集合
     * @param key 键
     * @param values 集合
     */
    public void add(String key, Collection<Object> values) {
        redisTemplate.opsForSet().add(key, values.toArray());
    }

    /**
     * 添加集合
     * @param key 键
     * @param values 集合
     */
    public void add(String key, Object... values) {
        redisTemplate.opsForSet().add(key, values);
    }



    /**
     * 判断缓存是否存在
     * @param key 键
     * @return boolean
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 获取缓存
     * @param key 键
     * @return object
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 获取缓存并设置过期时间
     * @param key 键
     * @param time 超时时间，单位：秒
     * @return object
     */
    public Object get(String key, long time) {
    	return redisTemplate.opsForValue().getAndExpire(key, Duration.ofSeconds(time));
    }

    /**
     * 批量获取缓存
     * @param keys 键集合
     * @return list
     */
    public List<Object> getBatch(String... keys) {
    	return redisTemplate.opsForValue().multiGet(List.of(keys));
    }

    /**
     * 获取map缓存
     * @param key 键
     * @return map
     */
    public Map<Object, Object> getMap(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 获取map缓存
     * @param key 键
     * @param hKey hKey
     * @return object
     */
    public Object getMapValues(String key, String hKey) {
        return redisTemplate.opsForHash().get(key, hKey);
    }

    /**
     * 删除缓存
     * @param key 键
     */
    public void del(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 删除缓存
     * @param keys 键集合
     */
    public void delBatch(String... keys) {
        redisTemplate.delete(List.of(keys));
    }

    /**
     * 删除缓存
     * @param keys 键集合
     */
    public void delBatch(List<String> keys) {
        redisTemplate.delete(keys);
    }

    /**
     * 删除map中的缓存
     * @param key 键
     * @param hKey hKey
     */
    public void delMapValues(String key, String hKey) {
        redisTemplate.opsForHash().delete(key, hKey);
    }
}
